const Router = require('koa-router');
const { User } = require('../models/index');
const { getConnectionStatus } = require('../config/db');
const router = new Router({ prefix: '/api' });
const bcrypt = require('bcryptjs'); // 用于密码比对
const jwt = require('jsonwebtoken'); // 用于生成 token

// 登录接口
router.post('/login', async (ctx) => {
  const { phone, password } = ctx.request.body;
  
  // 参数校验
  if (!phone || !password) {
    return ctx.body = {
      code: 400,
      message: '手机号和密码不能为空'
    };
  }

  try {
    //查询全部用户
    const allUsers = await User.findAll();
    console.log(allUsers);  // 打印查询到的所有用户

    // 查询用户
    const user = await User.findOne({ where: { phone } });
    if (!user) {
      return ctx.body = {
        code: 401,
        message: '用户不存在'
      };
    }


    // 检查用户状态
    if (user.status === 0) {
      return ctx.body = {
        code: 401,
        message: '用户已禁用'
      };
    }

    // 校验密码
    // 注意：这里假设数据库中的密码是明文存储的，如果是加密的则需要使用正确的验证方式
    let isValidPassword = false;
    
    // 检查密码是否以 $2a$ 开头（bcrypt加密特征）
    if (user.password && user.password.startsWith('$2a$')) {
      // 如果是bcrypt加密的密码，则使用bcrypt.compare验证
      isValidPassword = await bcrypt.compare(password, user.password);
    } else {
      // 如果是明文密码，则直接比较
      isValidPassword = (password === user.password);
    }

    if (!isValidPassword) {
      return ctx.body = {
        code: 401,
        message: '密码错误'
      };
    }

    // 生成 JWT Token
    const token = jwt.sign(
      { userId: user.id, phone: user.phone },
      'huang', // 应该放在 config 文件中
      { expiresIn: '7d' }
    );

    ctx.body = {
      code: 200,
      message: '登录成功',
      data: {
        token,
        userInfo: {
          id: user.id,
          username: user.username || '用户' + user.id, // 修正字段名
          phone: user.phone
        }
      }
    };
  } catch (error) {
    console.error('登录错误:', error); // 添加错误日志
    ctx.body = {
      code: 500,
      message: '服务器错误',
      error: error.message
    };
  }
});

// 中间件：验证 JWT

// 根据id获取当前用户信息
router.get('/user/:id', async (ctx) => {
  try {
    const { id } = ctx.params;
    const user = await User.findByPk(id);
    if (!user) {
      ctx.body = {
        code: 404,
        message: '用户不存在'
      };
      return;
    }
    ctx.body = {
      code: 200,
      message: '获取用户信息成功',
      data: user
    };
  } catch (error) {
    ctx.body = {
      code: 500,
      message: '获取用户信息失败',
      error: error.message
    };
  }
});

// 获取用户信息接口
router.get('/user/info', async (ctx) => {
  try {
    const payload = verifyToken(ctx);
    if (!payload) {
      return;
    }

    const user = await User.findByPk(payload.userId, {
      attributes: ['id', 'username', 'phone', 'gender', 'birthDate']
    });

    if (!user) {
      ctx.body = {
        code: 404,
        message: '用户不存在'
      };
      return;
    }

    ctx.body = {
      code: 200,
      message: '获取用户信息成功',
      data: {
        id: user.id,
        username: user.username, // 保持与前端期望的字段名一致
        phone: user.phone,
        gender: user.gender,
        birthDate: user.birthDate
      }
    };
  } catch (error) {
    console.error('获取用户信息错误:', error);
    ctx.body = {
      code: 500,
      message: '服务器错误',
      error: error.message
    };
  }
});

// 获取用户列表
router.get('/users', async (ctx) => {
  try {
    const users = await User.findAll({
      attributes: { exclude: ['password'] } // 排除密码字段
    });
    
    ctx.body = {
      code: 200,
      message: '获取用户列表成功',
      data: users
    };
  } catch (error) {
    ctx.body = {
      code: 500,
      message: '获取用户列表失败',
      error: error.message
    };
  }
});

// // 创建用户
// router.post('/users', async (ctx) => {
//   try {
//     const { username, email, password } = ctx.request.body;
    
//     const user = await User.create({
//       username,
//       email,
//       password // 实际项目中应该加密存储
//     });
    
//     ctx.body = {
//       code: 201,
//       message: '用户创建成功',
//       data: {
//         id: user.id,
//         username: user.username,
//         email: user.email
//       }
//     };
//   } catch (error) {
//     ctx.body = {
//       code: 500,
//       message: '创建用户失败',
//       error: error.message
//     };
//   }
// });

// 启用并优化用户创建接口
router.post('/users', async (ctx) => {
  try {
    const { username, phone, password, gender, birthDate } = ctx.request.body;
    
    // 参数校验
    if (!phone || !password) {
      return ctx.body = {
        code: 400,
        message: '手机号和密码不能为空'
      };
    }
    
    // 验证手机号格式
    if (!/^1[3-9]\d{9}$/.test(phone)) {
      return ctx.body = {
        code: 400,
        message: '手机号格式不正确'
      };
    }
    
    // 检查用户是否已存在
    const existingUser = await User.findOne({ where: { phone } });
    if (existingUser) {
      return ctx.body = {
        code: 400,
        message: '该手机号已注册'
      };
    }
    
    // 注意：这里使用明文存储密码以便于测试
    // 实际项目中应该使用 bcrypt 加密存储
    const user = await User.create({
      username: username || '用户' + phone.substring(7),
      phone,
      password: password, // 明文存储（仅测试环境）
      gender: gender || 0,
      birthDate: birthDate || null,
      status: 1 // 默认启用
    });
    
    ctx.body = {
      code: 201,
      message: '用户创建成功',
      data: {
        id: user.id,
        username: user.username,
        phone: user.phone
      }
    };
  } catch (error) {
    console.error('创建用户失败:', error);
    ctx.body = {
      code: 500,
      message: '创建用户失败',
      error: error.message
    };
  }
});

// 更新用户信息接口 - 支持用户名、性别、出生日期等个人资料修改
router.post('/users/update', async (ctx) => {
  const payload = verifyToken(ctx);
  if (!payload) {
    return ctx.body = {
      code: 401,
      message: '未授权访问，请重新登录'
    };
  }

  try {
    const { username, gender, birthDate } = ctx.request.body;
    const userId = payload.userId;
    console.log('更新用户信息参数:', { username, gender, birthDate });
    
    // 检查用户是否存在
    const user = await User.findByPk(userId);
    if (!user) {
      return ctx.body = {
        code: 404,
        message: '用户不存在'
      };
    }
    
    // 准备要更新的字段
    const updateFields = {};
    
    if (username !== undefined) {
      updateFields.username = username;
    }
    
    if (gender !== undefined) {
      // 性别转换：将前端传递的字符串转换为数据库需要的整数值
      // 0-未知，1-男，2-女
      if (typeof gender === 'string') {
        if (gender === '男' || gender === 'male' || gender === '1') {
          updateFields.gender = 1;
        } else if (gender === '女' || gender === 'female' || gender === '2') {
          updateFields.gender = 2;
        } else {
          updateFields.gender = 0; // 默认未知
        }
      } else {
        updateFields.gender = parseInt(gender) || 0;
      }
    }
    
    if (birthDate !== undefined) {
      updateFields.birthDate = birthDate;
    }
    
    // 更新用户信息
    await user.update(updateFields);
    
    // 重新获取更新后的用户信息
    const updatedUser = await User.findByPk(userId, {
      attributes: ['id', 'username', 'phone', 'gender', 'birthDate']
    });
    
    ctx.body = {
      code: 200,
      message: '用户信息更新成功',
      data: {
        id: updatedUser.id,
        username: updatedUser.username, // 保持与前端期望的字段名一致
        phone: updatedUser.phone,
        gender: updatedUser.gender,
        birthDate: updatedUser.birthDate
      }
    };
  } catch (error) {
    console.error('更新用户信息错误:', error);
    ctx.body = {
      code: 500,
      message: '请填写完整的用户信息',
      error: error.message
    };
  }
});


// 修复verifyToken函数，使其作为中间件正确处理请求
function verifyToken(ctx, next) {
  const token = ctx.headers.authorization;
  if (!token) {
    ctx.status = 401;
    ctx.body = {
      code: 401,
      message: '未提供token'
    };
    return;
  }

  try {
    const payload = jwt.verify(token.replace('Bearer ', ''), 'your_jwt_secret_key');
    // 将用户信息设置到上下文，方便后续使用
    ctx.state.user = payload;
    if (next) {
      return next(); // 如果作为中间件调用，继续处理请求
    }
    return payload; // 如果直接调用，返回payload
  } catch (error) {
    console.error('Token验证失败:', error); // 添加错误日志以便调试
    ctx.status = 401;
    ctx.body = {
      code: 401,
      message: '无效的token'
    };
    return next ? null : null; // 确保无论哪种调用方式都不会继续处理
  }
}

module.exports = router;